/**
 * 用户认证状态管理工具
 * 提供登录状态检查、权限控制、页面跳转等功能
 */

import { getCurrentUserInfo as refreshUserInfo, checkAndNotifyDefaultPassword } from './user-api';

// 存储键名常量
const StorageKeys = {
  ACCESS_TOKEN: 'access_token',
  USER_INFO: 'user_info',
  LOGIN_TYPE: 'login_type',
  REMEMBER_ACCOUNT: 'remember_account',
};

/**
 * 检查用户是否已登录
 * @returns {boolean} 登录状态
 */
function isLoggedIn() {
  try {
    const token = wx.getStorageSync(StorageKeys.ACCESS_TOKEN);
    const userInfo = wx.getStorageSync(StorageKeys.USER_INFO);
    return !!(token && userInfo);
  } catch (error) {
    console.error('检查登录状态失败:', error);
    return false;
  }
}

/**
 * 获取当前用户信息
 * @returns {Object|null} 用户信息
 */
function getCurrentUser() {
  try {
    const userInfo = wx.getStorageSync(StorageKeys.USER_INFO);
    return userInfo || null;
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return null;
  }
}

/**
 * 获取当前用户token
 * @returns {string|null} token
 */
function getToken() {
  try {
    const token = wx.getStorageSync(StorageKeys.ACCESS_TOKEN);
    return token || null;
  } catch (error) {
    console.error('获取token失败:', error);
    return null;
  }
}

/**
 * 检查用户权限
 * @param {string|Array} permissions 需要的权限
 * @returns {boolean} 是否有权限
 */
function hasPermission(permissions) {
  const userInfo = getCurrentUser();
  if (!userInfo) return false;
  
  // 如果是管理员，拥有所有权限
  if (userInfo.role === 'admin') return true;
  
  // 检查具体权限，确保userPermissions是数组
  let userPermissions = userInfo.permissions || [];
  if (!Array.isArray(userPermissions)) {
    userPermissions = typeof userPermissions === 'string' ? [userPermissions] : [];
  }
  
  if (typeof permissions === 'string') {
    return userPermissions.includes(permissions);
  }
  
  if (Array.isArray(permissions)) {
    return permissions.some(permission => userPermissions.includes(permission));
  }
  
  return false;
}

/**
 * 检查用户角色
 * @param {string|Array} roles 需要的角色
 * @returns {boolean} 是否有角色
 */
function hasRole(roles) {
  const userInfo = getCurrentUser();
  if (!userInfo) return false;
  
  const userRole = userInfo.role || 'user';
  
  if (typeof roles === 'string') {
    return userRole === roles;
  }
  
  if (Array.isArray(roles)) {
    return roles.includes(userRole);
  }
  
  return false;
}

/**
 * 需要登录才能访问的页面检查
 * 如果未登录，自动跳转到登录页
 * @param {Object} options 配置选项
 * @param {string} options.redirectUrl 登录后要跳转的页面
 * @param {boolean} options.showModal 是否显示提示弹窗
 * @param {string} options.message 提示信息
 * @returns {boolean} 是否已登录
 */
function requireLogin(options = {}) {
  const {
    redirectUrl = '',
    showModal = true,
    message = '请先登录后再使用该功能'
  } = options;
  
  if (isLoggedIn()) {
    return true;
  }
  
  // 显示提示弹窗
  if (showModal) {
    wx.showModal({
      title: '需要登录',
      content: message,
      confirmText: '去登录',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          navigateToLogin(redirectUrl);
        }
      }
    });
  } else {
    navigateToLogin(redirectUrl);
  }
  
  return false;
}

/**
 * 需要特定权限才能访问的功能检查
 * @param {string|Array} permissions 需要的权限
 * @param {Object} options 配置选项
 * @returns {boolean} 是否有权限
 */
function requirePermission(permissions, options = {}) {
  const {
    showModal = true,
    message = '您没有权限访问该功能'
  } = options;
  
  if (!isLoggedIn()) {
    return requireLogin(options);
  }
  
  if (hasPermission(permissions)) {
    return true;
  }
  
  if (showModal) {
    wx.showModal({
      title: '权限不足',
      content: message,
      showCancel: false,
      confirmText: '知道了'
    });
  }
  
  return false;
}

/**
 * 需要特定角色才能访问的功能检查
 * @param {string|Array} roles 需要的角色
 * @param {Object} options 配置选项
 * @returns {boolean} 是否有角色
 */
function requireRole(roles, options = {}) {
  const {
    showModal = true,
    message = '您的账户等级不足，无法访问该功能'
  } = options;
  
  if (!isLoggedIn()) {
    return requireLogin(options);
  }
  
  if (hasRole(roles)) {
    return true;
  }
  
  if (showModal) {
    wx.showModal({
      title: '权限不足',
      content: message,
      showCancel: false,
      confirmText: '知道了'
    });
  }
  
  return false;
}

/**
 * 跳转到登录页面
 * @param {string} redirectUrl 登录后要跳转的页面
 */
function navigateToLogin(redirectUrl = '') {
  const loginPage = '/packageAuth/pages/login/login';
  
  if (redirectUrl) {
    // 将当前页面路径作为参数传递，登录后可以跳转回来
    wx.navigateTo({
      url: `${loginPage}?redirect=${encodeURIComponent(redirectUrl)}`
    });
  } else {
    wx.navigateTo({
      url: loginPage
    });
  }
}

/**
 * 退出登录
 * @param {Object} options 配置选项
 */
function logout(options = {}) {
  const {
    showModal = true,
    redirectToLogin = false,
    redirectUrl = '/pages/index/index'
  } = options;
  
  const doLogout = () => {
    try {
      // 清除本地存储的登录信息
      wx.removeStorageSync(StorageKeys.ACCESS_TOKEN);
      wx.removeStorageSync(StorageKeys.USER_INFO);
      wx.removeStorageSync(StorageKeys.LOGIN_TYPE);
      
      console.log('用户已退出登录');
      
      // 跳转页面
      if (redirectToLogin) {
        navigateToLogin();
      } else {
        wx.reLaunch({
          url: redirectUrl
        });
      }
    } catch (error) {
      console.error('退出登录失败:', error);
    }
  };
  
  if (showModal) {
    wx.showModal({
      title: '退出登录',
      content: '确定要退出登录吗？',
      confirmText: '确定',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          doLogout();
        }
      }
    });
  } else {
    doLogout();
  }
}

/**
 * 获取用户等级信息
 * @returns {Object} 用户等级信息
 */
function getUserLevel() {
  const userInfo = getCurrentUser();
  if (!userInfo) {
    return {
      level: 'guest',
      name: '游客',
      permissions: []
    };
  }
  
  const role = userInfo.role || 'user';
  const levelMap = {
    'admin': { level: 'admin', name: '管理员', permissions: ['*'] },
    'vip': { level: 'vip', name: 'VIP会员', permissions: ['create_task', 'view_own_tasks', 'premium_features'] },
    'premium': { level: 'premium', name: '高级会员', permissions: ['create_task', 'view_own_tasks', 'premium_features'] },
    'user': { level: 'user', name: '普通用户', permissions: ['create_task', 'view_own_tasks'] }
  };
  
  return levelMap[role] || levelMap['user'];
}

/**
 * 页面载入时的登录状态检查（用于页面onLoad）
 * @param {Object} page 页面实例
 * @param {Object} options 页面参数
 * @param {boolean} requireAuth 是否需要登录
 */
function checkAuthOnPageLoad(page, options = {}, requireAuth = false) {
  if (requireAuth && !isLoggedIn()) {
    // 如果需要登录但未登录，跳转到登录页
    const currentPages = getCurrentPages();
    const currentPage = currentPages[currentPages.length - 1];
    const currentRoute = currentPage ? currentPage.route : '';
    
    navigateToLogin(currentRoute);
    return false;
  }
  
  // 在页面数据中设置用户信息
  if (page && page.setData) {
    page.setData({
      isLoggedIn: isLoggedIn(),
      userInfo: getCurrentUser(),
      userLevel: getUserLevel()
    });
  }
  
  return true;
}

/**
 * 按钮点击时的权限检查
 * @param {string|Array} permissions 需要的权限
 * @param {Function} callback 有权限时的回调函数
 * @param {Object} options 配置选项
 */
function checkPermissionAndExecute(permissions, callback, options = {}) {
  if (requirePermission(permissions, options)) {
    if (typeof callback === 'function') {
      callback();
    }
  }
}

/**
 * 从后端刷新用户信息
 * @returns {Promise<boolean>} 是否刷新成功
 */
async function refreshUserInfoFromBackend() {
  try {
    if (!isLoggedIn()) {
      return false;
    }
    
    const result = await refreshUserInfo();
    if (result.success) {
      console.log('🔄 用户信息已从后端刷新');
      return true;
    } else {
      console.error('刷新用户信息失败:', result.message);
      return false;
    }
  } catch (error) {
    console.error('刷新用户信息异常:', error);
    return false;
  }
}

/**
 * 检查并处理默认密码
 */
function handleDefaultPassword() {
  if (isLoggedIn()) {
    setTimeout(() => {
      checkAndNotifyDefaultPassword();
    }, 1000); // 延迟1秒显示提醒，避免影响登录流程
  }
}

module.exports = {
  // 基础状态检查
  isLoggedIn,
  getCurrentUser,
  getToken,
  getUserLevel,
  
  // 权限检查
  hasPermission,
  hasRole,
  requireLogin,
  requirePermission,
  requireRole,
  
  // 页面控制
  navigateToLogin,
  logout,
  checkAuthOnPageLoad,
  checkPermissionAndExecute,
  
  // 用户信息管理
  refreshUserInfo: refreshUserInfoFromBackend,
  checkAndNotifyDefaultPassword,
  handleDefaultPassword,
  
  // 常量
  StorageKeys
}; 